package com.dy.nygl.service.impl;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.annotation.Resource;

import org.springframework.stereotype.Service;

import com.dy.nygl.mapper.CostAnalysisMapper;
import com.dy.nygl.mapper.MachineMapper;
import com.dy.nygl.mapper.ReportSummaryMapper;
import com.dy.nygl.pojo.ReportSummary;
import com.dy.nygl.service.MachineService;
import com.dy.nygl.service.ReportSummaryService;

/**
 *  未完成：run() 方法 ---- > 预计自动生成数据库信息。
 *  相同Time名不得写入。
 * 
 * 本类完成功能： 
 * 1. addReportTimeAndTask ---> 生成report_summary表信息，通过将每月的总成本的记录，实现了每年的自动统计， 通过数据表信息完成对 任务名下的能源消耗进行了统计成本分析，并且记录于report_summary。
 * 2. selectByTimeAndTypeTask ---> 对report_summary表的查询。
 * 3. getEveryMonthTotal --- > 生成每月每种能源的基本消耗成本。
 * 4. getEveryYearTotal ---- > 生成每年每种能源的基本消耗成本。
 * 5. getTaskNameTotal ----- > 分析任务名下的各能源消耗量。
 * 6. efficiencyManager ---- > 通过对 相同后缀名的任务名
 * 除此之外都是附属。
 */
// 问题1：按年插入出现了问题

/**
 * select data from machine where collection_time between '2013-10-01 00:00:00'and '2013-10-31 23:59:59' and monitor_media = '6';
 * select total from report_summary where time='2016';
 * @author Administrator
 *
 */
@Service("reportSummaryService")
public class ReportSummaryServiceImpl implements ReportSummaryService, Runnable {

	@Resource(name = "reportSummaryDao")
	private ReportSummaryMapper reportSummaryDao;

	@Resource(name = "costAnalysisDao")
	private CostAnalysisMapper costAnalysisDao;

	@Resource(name = "machineDao")
	private MachineMapper machineDao;

	@Resource(name = "machineService")
	private MachineService machineService;

	private DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

	// 线程自动获取每月数据表消息
	@SuppressWarnings("deprecation")
	@Override
	public void run() {
		String time;
		Date d1,d2 = null;
		System.err.println("进入线程。。。");
		while (true) {
			try {
				d1 = Calendar.getInstance().getTime();
				Thread.sleep(1000*60*60*24);
				d2 = Calendar.getInstance().getTime();
				if(d1.getMonth()!=d2.getMonth()){
					break;
				}
			} catch (InterruptedException e1) {
				e1.printStackTrace();
			}
			try {
				time = d2.getYear()+"-"+d2.getMonth();
				addReportTimeAndTask(time);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}
	
	public List<String> selectYear(String time){
		List<String> s = reportSummaryDao.selectTime(time);
		return s;
	}
	
	/**
	 * 管理任务名，显示相同后缀名每种能源的平均值，具体的差产值和其他的成本有人工自己去做，或者可以交由参数配置（设置产值、任务名存入数据库）的总值与产值进行运算。
	 * totalProfit 。生产多少商品需要多少成本
	 */
	public String efficiencyManager(String time, String totalProfit) {
		System.err.println("进入efficiencyManager.......");
		List<String> all = getTaskNameTotal(time);
		int ave = startYear();
		List<String> s =  new ArrayList<>();
		for(int i = 0; i<all.size();i++){
			// 将totalProfit、all能源类型总成本平均值（*年份）转型为double，两数相除得到效率，再转型存储到数组中。
			s.add(String.valueOf(Double.valueOf(all.get(i))*ave));	
		}
		Double d = Double.valueOf(yearTotal(s))/Double.valueOf(totalProfit);
		String effect = String.valueOf(d);
		System.err.println(effect);
		return effect;
	}
	
	public List<String> efficiencyHub(String object){
		char[] num = object.toCharArray();
		List<String> All = new ArrayList<>();
		if(Character.isDigit(num[0]) && object.length()>=1 && object.length()<=2 ) {
			System.err.println("判断为月");
			All = getEveryMonthTotal();
			return All;
		} else if (Character.isDigit(num[0]) && object.length()==4) {
			System.err.println("判断为年");
			All = getEveryYearTotal(object);
			return All;
		} else if (Character.isDigit(num[0])==false) {
			All = getTaskNameTotal(object);
			return All;
		}
		return All;
	}
	
	/**
	 * 效率分析：分析任务名下的能源消耗量。 ---> 给定任务名（任务名后缀要统一，以/后缀结尾），目的是显示后缀相同任务名的基本能耗情况，取出各能源的平均值作为任务名的效率对比参数。
	 * 得到 一组以能源类型排序、历年来类似任务的、能源的总成本的平均值。
	 */
	public List<String> getTaskNameTotal(String time){
		List<String> listCode = costAnalysisDao.selectCodeMapper();
		System.out.println(listCode);
		int ave = startYear();
		List<String> all = new ArrayList<>(); 
		List<String> content = new ArrayList<>(); 
		String TaskTotalAve = null;
		for(int i=0;i<listCode.size();i++){
			content.addAll(reportSummaryDao.selectTotalByBlurryByMonthTaskName(time, listCode.get(i)));	// 获得以任务名结尾的某种能源消耗的总成本。
			TaskTotalAve = String.valueOf(Double.valueOf(yearTotal(content))/ave);
			all.add(TaskTotalAve);
			content.clear();
		}
		System.err.println(all);
		return all;
	}
	
	/**
	 * 效率分析：生成每月每种能源的基本消耗成本。 ---> 拿到一个以月份排序方式、各能源总消耗总成本的平均值的集合
	 */
	public List<String> getEveryMonthTotal() {
		System.err.println("进入getEveryMonthTotal.......");
		List<String> listCode = costAnalysisDao.selectCodeMapper();
		String everyMonthToalAve = null ;
		int ave = 0;
		System.err.println(ave); 
		List<String> month = new ArrayList<>();
		List<String> all = new ArrayList<>();
		List<String> one = new ArrayList<>();
		// 拿到月份
		for(int i=1;i<13;i++){
			month.add("-"+i);
		}
		System.err.println("开始粘合。。。。");
		// 通过能源和月份，获得以月份总体排布，能源类型为第二排布的集合。
		for(int i=0;i<month.size();i++){
			for(int j=0;j<listCode.size();j++){
				all.addAll(reportSummaryDao.selectTotalByBlurryByMonthTaskName(month.get(i),listCode.get(j)));
				everyMonthToalAve = String.valueOf(Double.valueOf(yearTotal(all))/ave);
				ave = startYear();
				System.err.println(ave);
				one.add(everyMonthToalAve);
				System.err.println("第"+i+1+"次="+one);
				all.clear();
			}
		}
		return one;
	}
	/**
	 * 效率分析：生成每年 、每种能源的基本消耗成本。 ---> 拿到一个以能源类型排序方式、历年各能源总消耗的总成本平均值的集合，目前长度为6
	 */
	public List<String> getEveryYearTotal(String time) {
		System.err.println("进入getEveryYearTotal.......");
		List<Double> everyYearToal = new ArrayList<>();
		List<String> everyYearToalAve = new ArrayList<>();
		List<String> listCode = costAnalysisDao.selectCodeMapper();
		List<ReportSummary> year = getEveryYear(); // 没统计。
		System.err.println(year);
		int ave = startYear();
		System.err.println(ave);
		for (int i = 0; i < listCode.size(); i++) {
			for (int j = 0; j < year.size(); j++) {
				if (listCode.get(i).equals(year.get(j).getEnergyType())) { // 拿到一组以能源类型为排序方式的能源总和
					everyYearToal.add(Double.valueOf(year.get(j).getTotal()));
				}
			}
		}
		System.out.println(everyYearToal);
		for(int i = 0;i<everyYearToal.size();i++){
			everyYearToalAve.add(String.valueOf(everyYearToal.get(i)/ave));
		}
		System.err.println(everyYearToalAve);
		return everyYearToalAve;
	}
	
	// 服务于上。找到所有年份对象
	public List<ReportSummary> getEveryYear() {
		System.err.println("进入getEveryYear.......");
		List<ReportSummary> all = reportSummaryDao.selectAll();	// 查询report_summary表的所有信息。
		List<ReportSummary> one = new ArrayList<>();
		
		for (int i = 0; i < all.size(); i++) {
			try {
				int j = Integer.parseInt(all.get(i).getTime()); // 找到所有年份
				one.add(all.get(i));
			} catch (Exception e) {
				
			}
		}
		System.err.println(one);
		return one;
	}
	
	// 一共多少年 ---> 求平均值
	public int startYear(){
		System.err.println("进入startYear.......");
		List<String> str = reportSummaryDao.Time();// 获得report表中所有的Time
		List<Integer> inte = new ArrayList<>();
		for(int i = 0; i < str.size(); i++){
			if(str.get(i).length()==4){
				inte.add(Integer.parseInt(str.get(i)));
			}
		}
		System.err.println(inte);
     	int reduce = (Collections.max(inte)-Collections.min(inte))+1;
     	if(reduce==0) reduce += reduce+1;
        return reduce;
	}

	// 根据 能源类型 、时间 查找历史记录，返回List<ReportSummary>对象,返回12个数据
	public List<String> selectByTimeAndTypeTask(String object,String time) {
		System.err.println("进入selectByTimeAndTypeTask.......");
		List<String> list = new ArrayList<>();
		char[] num = object.toCharArray();

		// 拿到所有年的总量
		if (object.length() < 2 && Character.isDigit(num[0]) && time!=null) {
			System.err.println("按能源、月类型查找。。。。。");
			list.addAll(reportSummaryDao.selectTotalByEnergyType(object, time)); // 判断能源需要时间才能显示
			
		} else if (object.length() < 5 && Character.isDigit(num[0])) {
			System.err.println("按年查找。。。。。");
			list.addAll((reportSummaryDao.selectAllToTotal(object)));	// 拿到最近五年的信息，从前往后
		} else if (object.length() < 8 && Character.isDigit(num[0])){
			System.err.println("按月查找。。。。。");
			list.addAll(reportSummaryDao.selectAllToTotal(object));
		} else if (object.length() < 8 ) {
			System.err.println("按任务名查找。。。。。");
			list.addAll(reportSummaryDao.selectAllToTotal(object));
		}
		System.err.println(list);
		return list;
	}
	

	// 记录 年、月 、不同能源总成本，插入数据库。
	public int addReportTimeAndTask(String time) throws Exception {
		System.err.println("进入 addReportTimeAndTask 。。。");
		ReportSummary report = new ReportSummary();
		List<String> listCode = costAnalysisDao.selectCodeMapper();
		char[] num = time.toCharArray();
		List<Double> listPrice = price();// 单价
		List<Double> taskNameTotal = new ArrayList<>();
		List<Double> taskName = new ArrayList<>();
		List<Double> Total = new ArrayList<>();
		List<String> year = new ArrayList<>();
		int j = 0;

		System.err.println("判断时间任务名之前。。。"+time);
		if (Character.isDigit(num[0])&&time.length()<5) { // 判断为年
			year = findReportYear(time);
		} else if ( Character.isDigit(num[0])&&time.length()<8){ // 判断为年月
			List<Double> total = selectTotal(time);// 总量
			Total = priceTotalPrice(listPrice, total);// 总成本
		}else {
			taskName = taskNameType(time); // 判断为任务名
			taskNameTotal = priceTotalPrice(listPrice, taskName);// 任务名总价
		}
		System.err.println("进入总成本的分析、数据插入");
		for (int i = 0; i < listCode.size(); i++) {
			System.err.println("开始进入修改");
			if (time.length() < 5 && Character.isDigit(num[0])) {
				System.err.println("进入年的判断。。。。。。");
				report.setTotal(year.get(i));

			} else if (time.length() < 8 && Character.isDigit(num[0])) {
				System.err.println("进入月 的判断。。。。。。");
				report.setTotal(String.valueOf(Total.get(i)));

			} else if (Character.isDigit(num[0]) == false) {
				System.err.println("进入任务名的判断。。。。。。");
				report.setTotal(String.valueOf(taskNameTotal.get(i)));
			}
			report.setTime(time);
			report.setEnergyType(listCode.get(i));
			report.setPrice(String.valueOf(listPrice.get(i)));
			System.err.println("开始插入数据、。。。。。");
			j = reportSummaryDao.insert(report);
		}
		return j;
	}
	// 以下服务于上
	// 能源分析: 任务名效率的分析 ------> 计算出每种完成任务的基本成本
	public List<Double> taskNameType(String taskname) {
		System.err.println("进入taskNameType.......");
		List<String> listCode = costAnalysisDao.selectCodeMapper();
		List<Double> taskByType = new ArrayList<>();
		for (int i = 0; i < listCode.size(); i++) {
			
			taskByType.add(machineService.timeAdd(machineDao.selectTaskName(taskname, listCode.get(i))));// 第i种能源的总消耗,相加在taskByType集合中。
		}
		return taskByType;
	}

	// 查找能源 一年总成本。字段：年、能源类型、能源总消耗、能源单价
	public List<String> findReportYear(String time) {
		List<String> listCode = costAnalysisDao.selectCodeMapper();
		List<String> list = new ArrayList<>();
		System.err.println("进入findReportYear......");
		List<String> s = new ArrayList<>();
		// 按照能源的顺序添加到集合中。通过该方法将其累加，并且转化为String类型.模糊查询本表的time，能源字段。返回list总量,String类型
		for (int i = 0; i < listCode.size(); i++) {
			list.addAll(reportSummaryDao.selectTotalByBlurryByYear(time, listCode.get(i)));
			System.err.println(list);
			s.add(yearTotal(list));
			list.clear();
		}
		System.err.println(s);
		return s;
	}

	// 能源、每年、总和，转数据类型。
	public String yearTotal(List<String> total) {
		System.err.println("进入yearTotal......");
		System.err.println(total);
		Double yearTotal = 0.0;
		for (int i = 0; i < total.size(); i++) {
			yearTotal += Double.valueOf(total.get(i));
		}
		System.err.println(yearTotal);
		return String.valueOf(yearTotal);
	}

	// 整合 单价、能源总量
	public List<Double> priceTotalPrice(List<Double> price, List<Double> total) throws ParseException {
		System.err.println("进入priceTotalPrice......");
		List<Double> Total = new ArrayList<>();
		for (int i = 0; i < price.size(); i++) {
			Total.add(i, price.get(i) * total.get(i));
		}
		System.err.println(Total);
		return Total;
	}

	// 通过CostAnalysis的code，获取price的集合。
	public List<Double> price() {
		System.err.println("进入price 方法。。。。。");
		List<String> listCode = costAnalysisDao.selectCodeMapper();
		System.err.println(listCode);
		List<Double> listPrice = new ArrayList<>();
		for (int i = 0; i < listCode.size(); i++) {
			listPrice.add(costAnalysisDao.selectPriceByCode(listCode.get(i)));
		}
		System.err.println(listPrice);
		return listPrice;
	}

	// 给定时间 月查找逐个自动查找总量 返回list集合。
	public List<Double> selectTotal(String time) throws ParseException {
		System.err.println("进入时间管理阶段。。。。。。。");
		List<String> listCode = costAnalysisDao.selectCodeMapper();
		List<Double> total = new ArrayList<>();
		Date time1 = dateFormat.parse(time + "-01" + " " + "00:00:00");
		Date time2 = dateFormat.parse(time + "-" + time(time) + " " + "23:59:59");
		for (int i = 0; i < listCode.size(); i++) {
			// 通过listCode获取成本分析表中对应的能源编号，再根据时间获取每种能源在数据库中的信息相加,并且放置在Map中。
			total.add(machineService.timeAdd((machineDao.selectMonitorMedia(listCode.get(i), time1, time2))));
		}
		System.err.println(total);
		return total;
	}

	// 获取每月最大天数 time的格式为：2016-02
	public int time(String time) {
		System.err.println("进入time......");
		Calendar cal = Calendar.getInstance();
		cal.set(Calendar.YEAR, Integer.parseInt(time.substring(0, 4)));
		cal.set(Calendar.MONTH, Integer.parseInt(time.substring(5, time.length())) - 1);
		return cal.getActualMaximum(Calendar.DAY_OF_MONTH);
	}

}
